package com.ourteam.datawarehouse.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2019-02-13 11:54:29 Warning ! This file will be overwrite when
 * regenerate !
 */
public class DataSourceDAOQueryBean extends BaseQueryBean {

  public DataSourceDAOQueryBean() {
    super();
  }

  public DataSourceDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public DataSourceDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.Id, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.Id, "id");
    }
  }

  public void addDataSourceTypeSelectProperty() {
    addDataSourceTypeSelectProperty("dataSourceType");
  }

  public void addDataSourceTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.DataSourceType, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.DataSourceType, "dataSourceType");
    }
  }

  public void addDataSourceCodeSelectProperty() {
    addDataSourceCodeSelectProperty("dataSourceCode");
  }

  public void addDataSourceCodeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.DataSourceCode, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.DataSourceCode, "dataSourceCode");
    }
  }

  public void addDataSourceUrlSelectProperty() {
    addDataSourceUrlSelectProperty("dataSourceUrl");
  }

  public void addDataSourceUrlSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.DataSourceUrl, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.DataSourceUrl, "dataSourceUrl");
    }
  }

  public void addDataSourceAccountSelectProperty() {
    addDataSourceAccountSelectProperty("dataSourceAccount");
  }

  public void addDataSourceAccountSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.DataSourceAccount, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.DataSourceAccount, "dataSourceAccount");
    }
  }

  public void addDataSourcePasswordSelectProperty() {
    addDataSourcePasswordSelectProperty("dataSourcePassword");
  }

  public void addDataSourcePasswordSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.DataSourcePassword, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.DataSourcePassword, "dataSourcePassword");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.Status, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IDataSourceDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IDataSourceDAO.Remarks, "remarks");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addDataSourceTypeSelectProperty();

    addDataSourceCodeSelectProperty();

    addDataSourceUrlSelectProperty();

    addDataSourceAccountSelectProperty();

    addDataSourcePasswordSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<DataSourceDAOQueryBean> {

    protected Criteria(DataSourceDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IDataSourceDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IDataSourceDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(IDataSourceDAO.Id + " is not null AND " + IDataSourceDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion("(" + IDataSourceDAO.Id + " is null OR " + IDataSourceDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " is null OR " + IDataSourceDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IDataSourceDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IDataSourceDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IDataSourceDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IDataSourceDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IDataSourceDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IDataSourceDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IDataSourceDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andDataSourceTypeIsNull() {
      addCriterion(IDataSourceDAO.DataSourceType + " is null");
      return this;
    }

    public Criteria andDataSourceTypeIsNotNull() {
      addCriterion(IDataSourceDAO.DataSourceType + " is not null");
      return this;
    }

    public Criteria andDataSourceTypeIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.DataSourceType
              + " is not null AND "
              + IDataSourceDAO.DataSourceType
              + " <> ''");
      return this;
    }

    public Criteria andDataSourceTypeIsEmpty() {
      addCriterion(
          "("
              + IDataSourceDAO.DataSourceType
              + " is null OR "
              + IDataSourceDAO.DataSourceType
              + " = '')");
      return this;
    }

    public Criteria andDataSourceTypeEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " = ", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " <>", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.DataSourceType + " is null OR " + IDataSourceDAO.DataSourceType + " <>",
          value,
          "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeGreaterThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " >", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " >=", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeLessThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " <", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceType + " <=", value, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.DataSourceType + " like", buffer.toString(), "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourceType + " not like", buffer.toString(), "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andDataSourceTypeEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceType + " in", values, "dataSourceType");
        return this;
      }
    }

    public Criteria andDataSourceTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDataSourceTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceType + " not in", values, "dataSourceType");
        return this;
      }
    }

    public Criteria andDataSourceTypeIn(String[] values) {

      if (values.length == 1) {
        return andDataSourceTypeEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceType + " in", Arrays.asList(values), "dataSourceType");
        return this;
      }
    }

    public Criteria andDataSourceTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andDataSourceTypeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceType + " not in", Arrays.asList(values), "dataSourceType");
        return this;
      }
    }

    public Criteria andDataSourceTypeIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceTypeBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.DataSourceType + " between", value1, value2, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceTypeNotBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourceType + " not between", value1, value2, "dataSourceType");
      return this;
    }

    public Criteria andDataSourceCodeIsNull() {
      addCriterion(IDataSourceDAO.DataSourceCode + " is null");
      return this;
    }

    public Criteria andDataSourceCodeIsNotNull() {
      addCriterion(IDataSourceDAO.DataSourceCode + " is not null");
      return this;
    }

    public Criteria andDataSourceCodeIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.DataSourceCode
              + " is not null AND "
              + IDataSourceDAO.DataSourceCode
              + " <> ''");
      return this;
    }

    public Criteria andDataSourceCodeIsEmpty() {
      addCriterion(
          "("
              + IDataSourceDAO.DataSourceCode
              + " is null OR "
              + IDataSourceDAO.DataSourceCode
              + " = '')");
      return this;
    }

    public Criteria andDataSourceCodeEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " = ", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " <>", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.DataSourceCode + " is null OR " + IDataSourceDAO.DataSourceCode + " <>",
          value,
          "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeGreaterThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " >", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " >=", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeLessThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " <", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceCode + " <=", value, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceCode);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceCodeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.DataSourceCode + " like", buffer.toString(), "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourceCode + " not like", buffer.toString(), "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeIn(List<String> values) {

      if (values.size() == 1) {
        return andDataSourceCodeEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceCode + " in", values, "dataSourceCode");
        return this;
      }
    }

    public Criteria andDataSourceCodeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDataSourceCodeNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceCode + " not in", values, "dataSourceCode");
        return this;
      }
    }

    public Criteria andDataSourceCodeIn(String[] values) {

      if (values.length == 1) {
        return andDataSourceCodeEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceCode + " in", Arrays.asList(values), "dataSourceCode");
        return this;
      }
    }

    public Criteria andDataSourceCodeNotIn(String[] values) {
      if (values.length == 1) {
        return andDataSourceCodeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceCode + " not in", Arrays.asList(values), "dataSourceCode");
        return this;
      }
    }

    public Criteria andDataSourceCodeIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceCode + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceCodeBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.DataSourceCode + " between", value1, value2, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceCodeNotBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourceCode + " not between", value1, value2, "dataSourceCode");
      return this;
    }

    public Criteria andDataSourceUrlIsNull() {
      addCriterion(IDataSourceDAO.DataSourceUrl + " is null");
      return this;
    }

    public Criteria andDataSourceUrlIsNotNull() {
      addCriterion(IDataSourceDAO.DataSourceUrl + " is not null");
      return this;
    }

    public Criteria andDataSourceUrlIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.DataSourceUrl
              + " is not null AND "
              + IDataSourceDAO.DataSourceUrl
              + " <> ''");
      return this;
    }

    public Criteria andDataSourceUrlIsEmpty() {
      addCriterion(
          "("
              + IDataSourceDAO.DataSourceUrl
              + " is null OR "
              + IDataSourceDAO.DataSourceUrl
              + " = '')");
      return this;
    }

    public Criteria andDataSourceUrlEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " = ", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " <>", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.DataSourceUrl + " is null OR " + IDataSourceDAO.DataSourceUrl + " <>",
          value,
          "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlGreaterThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " >", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " >=", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlLessThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " <", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceUrl + " <=", value, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceUrl);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceUrlLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.DataSourceUrl + " like", buffer.toString(), "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.DataSourceUrl + " not like", buffer.toString(), "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlIn(List<String> values) {

      if (values.size() == 1) {
        return andDataSourceUrlEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceUrl + " in", values, "dataSourceUrl");
        return this;
      }
    }

    public Criteria andDataSourceUrlNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDataSourceUrlNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceUrl + " not in", values, "dataSourceUrl");
        return this;
      }
    }

    public Criteria andDataSourceUrlIn(String[] values) {

      if (values.length == 1) {
        return andDataSourceUrlEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.DataSourceUrl + " in", Arrays.asList(values), "dataSourceUrl");
        return this;
      }
    }

    public Criteria andDataSourceUrlNotIn(String[] values) {
      if (values.length == 1) {
        return andDataSourceUrlNotEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceUrl + " not in", Arrays.asList(values), "dataSourceUrl");
        return this;
      }
    }

    public Criteria andDataSourceUrlIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceUrlBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " between", value1, value2, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceUrlNotBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.DataSourceUrl + " not between", value1, value2, "dataSourceUrl");
      return this;
    }

    public Criteria andDataSourceAccountIsNull() {
      addCriterion(IDataSourceDAO.DataSourceAccount + " is null");
      return this;
    }

    public Criteria andDataSourceAccountIsNotNull() {
      addCriterion(IDataSourceDAO.DataSourceAccount + " is not null");
      return this;
    }

    public Criteria andDataSourceAccountIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.DataSourceAccount
              + " is not null AND "
              + IDataSourceDAO.DataSourceAccount
              + " <> ''");
      return this;
    }

    public Criteria andDataSourceAccountIsEmpty() {
      addCriterion(
          "("
              + IDataSourceDAO.DataSourceAccount
              + " is null OR "
              + IDataSourceDAO.DataSourceAccount
              + " = '')");
      return this;
    }

    public Criteria andDataSourceAccountEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " = ", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " <>", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.DataSourceAccount
              + " is null OR "
              + IDataSourceDAO.DataSourceAccount
              + " <>",
          value,
          "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountGreaterThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " >", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " >=", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountLessThan(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " <", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourceAccount + " <=", value, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourceAccount);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourceAccountLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourceAccount + " like", buffer.toString(), "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourceAccount + " not like", buffer.toString(), "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountIn(List<String> values) {

      if (values.size() == 1) {
        return andDataSourceAccountEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceAccount + " in", values, "dataSourceAccount");
        return this;
      }
    }

    public Criteria andDataSourceAccountNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDataSourceAccountNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourceAccount + " not in", values, "dataSourceAccount");
        return this;
      }
    }

    public Criteria andDataSourceAccountIn(String[] values) {

      if (values.length == 1) {
        return andDataSourceAccountEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceAccount + " in", Arrays.asList(values), "dataSourceAccount");
        return this;
      }
    }

    public Criteria andDataSourceAccountNotIn(String[] values) {
      if (values.length == 1) {
        return andDataSourceAccountNotEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourceAccount + " not in",
            Arrays.asList(values),
            "dataSourceAccount");
        return this;
      }
    }

    public Criteria andDataSourceAccountIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourceAccount + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourceAccountBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourceAccount + " between", value1, value2, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourceAccountNotBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourceAccount + " not between", value1, value2, "dataSourceAccount");
      return this;
    }

    public Criteria andDataSourcePasswordIsNull() {
      addCriterion(IDataSourceDAO.DataSourcePassword + " is null");
      return this;
    }

    public Criteria andDataSourcePasswordIsNotNull() {
      addCriterion(IDataSourceDAO.DataSourcePassword + " is not null");
      return this;
    }

    public Criteria andDataSourcePasswordIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.DataSourcePassword
              + " is not null AND "
              + IDataSourceDAO.DataSourcePassword
              + " <> ''");
      return this;
    }

    public Criteria andDataSourcePasswordIsEmpty() {
      addCriterion(
          "("
              + IDataSourceDAO.DataSourcePassword
              + " is null OR "
              + IDataSourceDAO.DataSourcePassword
              + " = '')");
      return this;
    }

    public Criteria andDataSourcePasswordEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " = ", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " <>", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.DataSourcePassword
              + " is null OR "
              + IDataSourceDAO.DataSourcePassword
              + " <>",
          value,
          "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThan(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " >", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " >=", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordLessThan(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " <", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.DataSourcePassword + " <=", value, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.DataSourcePassword);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDataSourcePasswordLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourcePassword + " like", buffer.toString(), "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IDataSourceDAO.DataSourcePassword + " not like", buffer.toString(), "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordIn(List<String> values) {

      if (values.size() == 1) {
        return andDataSourcePasswordEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourcePassword + " in", values, "dataSourcePassword");
        return this;
      }
    }

    public Criteria andDataSourcePasswordNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDataSourcePasswordNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.DataSourcePassword + " not in", values, "dataSourcePassword");
        return this;
      }
    }

    public Criteria andDataSourcePasswordIn(String[] values) {

      if (values.length == 1) {
        return andDataSourcePasswordEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourcePassword + " in", Arrays.asList(values), "dataSourcePassword");
        return this;
      }
    }

    public Criteria andDataSourcePasswordNotIn(String[] values) {
      if (values.length == 1) {
        return andDataSourcePasswordNotEqualTo(values[0]);
      } else {
        addCriterion(
            IDataSourceDAO.DataSourcePassword + " not in",
            Arrays.asList(values),
            "dataSourcePassword");
        return this;
      }
    }

    public Criteria andDataSourcePasswordIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.DataSourcePassword + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDataSourcePasswordBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourcePassword + " between", value1, value2, "dataSourcePassword");
      return this;
    }

    public Criteria andDataSourcePasswordNotBetween(String value1, String value2) {
      addCriterion(
          IDataSourceDAO.DataSourcePassword + " not between", value1, value2, "dataSourcePassword");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IDataSourceDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IDataSourceDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(IDataSourceDAO.Status + " is not null AND " + IDataSourceDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion("(" + IDataSourceDAO.Status + " is null OR " + IDataSourceDAO.Status + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IDataSourceDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.Status + " is null OR " + IDataSourceDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IDataSourceDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IDataSourceDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IDataSourceDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IDataSourceDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IDataSourceDAO.Remarks + " is not null AND " + IDataSourceDAO.Remarks + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "(" + IDataSourceDAO.Remarks + " is null OR " + IDataSourceDAO.Remarks + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IDataSourceDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IDataSourceDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IDataSourceDAO.Remarks + " is null OR " + IDataSourceDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IDataSourceDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IDataSourceDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IDataSourceDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IDataSourceDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IDataSourceDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IDataSourceDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IDataSourceDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IDataSourceDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IDataSourceDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }
  }
}
